Linux Cubed Series 4: GNU Archives/Linux Cubed Series 4 - GNU Archives.iso/gnu/glibc-1.09/glibc-1/glibc-1.09.1/manual/libc.cp

Text File | 1994-11-07 | 46.0 KB | 803 lines

\entry {library}{1}{library}
\entry {standards}{1}{standards}
\entry {ANSI C}{2}{ANSI C}
\entry {POSIX}{2}{POSIX}
\entry {POSIX.1}{2}{POSIX.1}
\entry {IEEE Std 1003.1}{2}{IEEE Std 1003.1}
\entry {POSIX.2}{2}{POSIX.2}
\entry {IEEE Std 1003.2}{2}{IEEE Std 1003.2}
\entry {BSD Unix}{3}{BSD Unix}
\entry {4.n BSD Unix}{3}{4.\var {n} BSD Unix}
\entry {Berkeley Unix}{3}{Berkeley Unix}
\entry {SunOS}{3}{SunOS}
\entry {Unix, Berkeley}{3}{Unix, Berkeley}
\entry {SVID}{3}{SVID}
\entry {System V Unix}{3}{System V Unix}
\entry {Unix, System V}{3}{Unix, System V}
\entry {header files}{4}{header files}
\entry {definition (compared to declaration)}{4}{definition (compared to declaration)}
\entry {declaration (compared to definition)}{4}{declaration (compared to definition)}
\entry {shadowing functions with macros}{5}{shadowing functions with macros}
\entry {removing macros that shadow functions}{5}{removing macros that shadow functions}
\entry {undefining macros that shadow functions}{5}{undefining macros that shadow functions}
\entry {reserved names}{6}{reserved names}
\entry {name space}{6}{name space}
\entry {feature test macros}{8}{feature test macros}
\entry {BSD compatibility library.}{9}{BSD compatibility library.}
\entry {error reporting}{13}{error reporting}
\entry {reporting errors}{13}{reporting errors}
\entry {error codes}{13}{error codes}
\entry {status codes}{13}{status codes}
\entry {program name}{24}{program name}
\entry {name of running program}{24}{name of running program}
\entry {memory allocation}{27}{memory allocation}
\entry {storage allocation}{27}{storage allocation}
\entry {dynamic allocation}{27}{dynamic allocation}
\entry {static allocation}{27}{static allocation}
\entry {automatic allocation}{27}{automatic allocation}
\entry {unconstrained storage allocation}{28}{unconstrained storage allocation}
\entry {malloc function}{28}{\code {malloc} function}
\entry {heap, dynamic allocation from}{28}{heap, dynamic allocation from}
\entry {allocation of memory with malloc}{28}{allocation of memory with \code {malloc}}
\entry {freeing memory allocated with malloc}{30}{freeing memory allocated with \code {malloc}}
\entry {heap, freeing memory from}{30}{heap, freeing memory from}
\entry {changing the size of a block (malloc)}{31}{changing the size of a block (\code {malloc})}
\entry {efficiency and malloc}{32}{efficiency and \code {malloc}}
\entry {page boundary}{33}{page boundary}
\entry {alignment (with malloc)}{33}{alignment (with \code {malloc})}
\entry {heap consistency checking}{33}{heap consistency checking}
\entry {consistency checking, of heap}{33}{consistency checking, of heap}
\entry {allocation hooks, for malloc}{35}{allocation hooks, for \code {malloc}}
\entry {allocation statistics}{36}{allocation statistics}
\entry {obstacks}{38}{obstacks}
\entry {allocation (obstacks)}{40}{allocation (obstacks)}
\entry {freeing (obstacks)}{41}{freeing (obstacks)}
\entry {macros}{41}{macros}
\entry {growing objects (in obstacks)}{42}{growing objects (in obstacks)}
\entry {changing the size of a block (obstacks)}{42}{changing the size of a block (obstacks)}
\entry {shrinking objects}{44}{shrinking objects}
\entry {efficiency and obstacks}{44}{efficiency and obstacks}
\entry {obstack status}{45}{obstack status}
\entry {status of obstack}{45}{status of obstack}
\entry {alignment (in obstacks)}{46}{alignment (in obstacks)}
\entry {efficiency of chunks}{46}{efficiency of chunks}
\entry {chunks}{46}{chunks}
\entry {automatic freeing}{49}{automatic freeing}
\entry {alloca function}{49}{\code {alloca} function}
\entry {automatic storage with variable size}{49}{automatic storage with variable size}
\entry {longjmp}{50}{longjmp}
\entry {alloca disadvantages}{51}{\code {alloca} disadvantages}
\entry {disadvantages of alloca}{51}{disadvantages of \code {alloca}}
\entry {variable-sized arrays}{51}{variable-sized arrays}
\entry {relocating memory allocator}{52}{relocating memory allocator}
\entry {handle}{52}{handle}
\entry {memory usage warnings}{53}{memory usage warnings}
\entry {warnings of memory almost full}{53}{warnings of memory almost full}
\entry {character testing}{55}{character testing}
\entry {classification of characters}{55}{classification of characters}
\entry {predicates on characters}{55}{predicates on characters}
\entry {character predicates}{55}{character predicates}
\entry {lower-case character}{55}{lower-case character}
\entry {upper-case character}{55}{upper-case character}
\entry {alphabetic character}{55}{alphabetic character}
\entry {digit character}{55}{digit character}
\entry {decimal digit character}{55}{decimal digit character}
\entry {alphanumeric character}{56}{alphanumeric character}
\entry {hexadecimal digit character}{56}{hexadecimal digit character}
\entry {punctuation character}{56}{punctuation character}
\entry {whitespace character}{56}{whitespace character}
\entry {blank character}{56}{blank character}
\entry {graphic character}{56}{graphic character}
\entry {printing character}{56}{printing character}
\entry {control character}{56}{control character}
\entry {ASCII character}{57}{ASCII character}
\entry {character case conversion}{57}{character case conversion}
\entry {case conversion of characters}{57}{case conversion of characters}
\entry {converting case of characters}{57}{converting case of characters}
\entry {string, representation of}{59}{string, representation of}
\entry {string}{59}{string}
\entry {null character}{59}{null character}
\entry {string literal}{59}{string literal}
\entry {length of string}{60}{length of string}
\entry {allocation size of string}{60}{allocation size of string}
\entry {size of string}{60}{size of string}
\entry {string length}{60}{string length}
\entry {string allocation}{60}{string allocation}
\entry {copying strings and arrays}{61}{copying strings and arrays}
\entry {string copy functions}{61}{string copy functions}
\entry {array copy functions}{61}{array copy functions}
\entry {concatenating strings}{61}{concatenating strings}
\entry {string concatenation functions}{61}{string concatenation functions}
\entry {comparing strings and arrays}{65}{comparing strings and arrays}
\entry {string comparison functions}{65}{string comparison functions}
\entry {array comparison functions}{65}{array comparison functions}
\entry {predicates on strings}{65}{predicates on strings}
\entry {predicates on arrays}{65}{predicates on arrays}
\entry {collating strings}{67}{collating strings}
\entry {string collation functions}{67}{string collation functions}
\entry {converting string to collation order}{68}{converting string to collation order}
\entry {search functions (for strings)}{70}{search functions (for strings)}
\entry {string search functions}{70}{string search functions}
\entry {tokenizing strings}{72}{tokenizing strings}
\entry {breaking a string into tokens}{72}{breaking a string into tokens}
\entry {parsing tokens from a string}{72}{parsing tokens from a string}
\entry {opening a file}{75}{opening a file}
\entry {file position}{77}{file position}
\entry {sequential-access files}{77}{sequential-access files}
\entry {random-access files}{77}{random-access files}
\entry {append-access files}{77}{append-access files}
\entry {file name}{77}{file name}
\entry {directory}{78}{directory}
\entry {link}{78}{link}
\entry {directory entry}{78}{directory entry}
\entry {file name component}{78}{file name component}
\entry {file name resolution}{78}{file name resolution}
\entry {root directory}{78}{root directory}
\entry {absolute file name}{78}{absolute file name}
\entry {relative file name}{78}{relative file name}
\entry {parent directory}{79}{parent directory}
\entry {file name syntax errors}{79}{file name syntax errors}
\entry {usual file name syntax errors}{79}{usual file name syntax errors}
\entry {file pointer}{83}{file pointer}
\entry {standard streams}{83}{standard streams}
\entry {streams, standard}{83}{streams, standard}
\entry {standard input stream}{83}{standard input stream}
\entry {standard output stream}{84}{standard output stream}
\entry {standard error stream}{84}{standard error stream}
\entry {opening a stream}{84}{opening a stream}
\entry {closing a stream}{86}{closing a stream}
\entry {writing to a stream, by characters}{87}{writing to a stream, by characters}
\entry {reading from a stream, by characters}{88}{reading from a stream, by characters}
\entry {peeking at input}{91}{peeking at input}
\entry {unreading characters}{91}{unreading characters}
\entry {pushing input back}{91}{pushing input back}
\entry {format string, for printf}{93}{format string, for \code {printf}}
\entry {template, for printf}{93}{template, for \code {printf}}
\entry {formatted output to a stream}{93}{formatted output to a stream}
\entry {writing to a stream, formatted}{93}{writing to a stream, formatted}
\entry {conversion specifications (printf)}{93}{conversion specifications (\code {printf})}
\entry {flag character (printf)}{94}{flag character (\code {printf})}
\entry {minimum field width (printf)}{94}{minimum field width (\code {printf})}
\entry {precision (printf)}{95}{precision (\code {printf})}
\entry {type modifier character (printf)}{95}{type modifier character (\code {printf})}
\entry {output conversions, for printf}{95}{output conversions, for \code {printf}}
\entry {parsing a template string}{105}{parsing a template string}
\entry {customizing printf}{109}{customizing \code {printf}}
\entry {defining new printf conversions}{109}{defining new \code {printf} conversions}
\entry {extending printf}{109}{extending \code {printf}}
\entry {formatted input from a stream}{113}{formatted input from a stream}
\entry {reading from a stream, formatted}{113}{reading from a stream, formatted}
\entry {format string, for scanf}{113}{format string, for \code {scanf}}
\entry {template, for scanf}{113}{template, for \code {scanf}}
\entry {conversion specifications (scanf)}{114}{conversion specifications (\code {scanf})}
\entry {matching failure, in scanf}{114}{matching failure, in \code {scanf}}
\entry {flag character (scanf)}{115}{flag character (\code {scanf})}
\entry {maximum field width (scanf)}{115}{maximum field width (\code {scanf})}
\entry {type modifier character (scanf)}{115}{type modifier character (\code {scanf})}
\entry {input conversions, for scanf}{116}{input conversions, for \code {scanf}}
\entry {binary I/O to a stream}{122}{binary I/O to a stream}
\entry {block I/O to a stream}{122}{block I/O to a stream}
\entry {reading from a stream, by blocks}{122}{reading from a stream, by blocks}
\entry {writing to a stream, by blocks}{122}{writing to a stream, by blocks}
\entry {end of file, on a stream}{123}{end of file, on a stream}
\entry {text stream}{124}{text stream}
\entry {binary stream}{124}{binary stream}
\entry {lines (in a text file)}{124}{lines (in a text file)}
\entry {file positioning on a stream}{125}{file positioning on a stream}
\entry {positioning a stream}{125}{positioning a stream}
\entry {seeking on a stream}{125}{seeking on a stream}
\entry {buffering of streams}{128}{buffering of streams}
\entry {unbuffered stream}{128}{unbuffered stream}
\entry {line buffered stream}{128}{line buffered stream}
\entry {fully buffered stream}{128}{fully buffered stream}
\entry {flushing a stream}{129}{flushing a stream}
\entry {buffering, controlling}{129}{buffering, controlling}
\entry {stream, for I/O to a string}{131}{stream, for I/O to a string}
\entry {string stream}{131}{string stream}
\entry {custom streams}{135}{custom streams}
\entry {programming your own streams}{135}{programming your own streams}
\entry {cookie, for custom stream}{135}{cookie, for custom stream}
\entry {hook functions (of custom streams)}{136}{hook functions (of custom streams)}
\entry {opening a file descriptor}{139}{opening a file descriptor}
\entry {closing a file descriptor}{139}{closing a file descriptor}
\entry {reading from a file descriptor}{141}{reading from a file descriptor}
\entry {end-of-file, on a file descriptor}{141}{end-of-file, on a file descriptor}
\entry {writing to a file descriptor}{142}{writing to a file descriptor}
\entry {file positioning on a file descriptor}{144}{file positioning on a file descriptor}
\entry {positioning a file descriptor}{144}{positioning a file descriptor}
\entry {seeking on a file descriptor}{144}{seeking on a file descriptor}
\entry {streams, and file descriptors}{146}{streams, and file descriptors}
\entry {converting file descriptor to stream}{146}{converting file descriptor to stream}
\entry {extracting file descriptor from stream}{146}{extracting file descriptor from stream}
\entry {standard file descriptors}{146}{standard file descriptors}
\entry {file descriptors, standard}{146}{file descriptors, standard}
\entry {standard input file descriptor}{147}{standard input file descriptor}
\entry {standard output file descriptor}{147}{standard output file descriptor}
\entry {standard error file descriptor}{147}{standard error file descriptor}
\entry {channels}{147}{channels}
\entry {streams and descriptors}{147}{streams and descriptors}
\entry {descriptors and streams}{147}{descriptors and streams}
\entry {mixing descriptors and streams}{147}{mixing descriptors and streams}
\entry {linked channels}{147}{linked channels}
\entry {cleaning up a stream}{147}{cleaning up a stream}
\entry {independent channels}{148}{independent channels}
\entry {waiting for input or output}{149}{waiting for input or output}
\entry {multiplexing input}{149}{multiplexing input}
\entry {input from multiple files}{149}{input from multiple files}
\entry {file descriptor sets, for select}{149}{file descriptor sets, for \code {select}}
\entry {control operations on files}{152}{control operations on files}
\entry {fcntl function}{152}{\code {fcntl} function}
\entry {duplicating file descriptors}{153}{duplicating file descriptors}
\entry {redirecting input and output}{153}{redirecting input and output}
\entry {file descriptor flags}{155}{file descriptor flags}
\entry {close-on-exec (file descriptor flag)}{156}{close-on-exec (file descriptor flag)}
\entry {file status flags}{156}{file status flags}
\entry {file name translation flags}{158}{file name translation flags}
\entry {flags, file name translation}{158}{flags, file name translation}
\entry {open-time action flags}{158}{open-time action flags}
\entry {flags, open-time action}{158}{flags, open-time action}
\entry {create on open (file status flag)}{158}{create on open (file status flag)}
\entry {non-blocking open}{158}{non-blocking open}
\entry {controlling terminal, setting}{159}{controlling terminal, setting}
\entry {symbolic link, opening}{159}{symbolic link, opening}
\entry {file locks}{162}{file locks}
\entry {record locking}{162}{record locking}
\entry {exclusive lock}{162}{exclusive lock}
\entry {write lock}{162}{write lock}
\entry {shared lock}{162}{shared lock}
\entry {read lock}{162}{read lock}
\entry {interrupt-driven input}{166}{interrupt-driven input}
\entry {current working directory}{169}{current working directory}
\entry {working directory}{169}{working directory}
\entry {change working directory}{169}{change working directory}
\entry {accessing directories}{171}{accessing directories}
\entry {reading from a directory}{171}{reading from a directory}
\entry {directories, accessing}{171}{directories, accessing}
\entry {directory stream}{171}{directory stream}
\entry {hard link}{175}{hard link}
\entry {link, hard}{175}{link, hard}
\entry {multiple names for one file}{175}{multiple names for one file}
\entry {file names, multiple}{175}{file names, multiple}
\entry {soft link}{176}{soft link}
\entry {link, soft}{176}{link, soft}
\entry {symbolic link}{176}{symbolic link}
\entry {link, symbolic}{176}{link, symbolic}
\entry {deleting a file}{178}{deleting a file}
\entry {removing a file}{178}{removing a file}
\entry {unlinking a file}{178}{unlinking a file}
\entry {directories, deleting}{178}{directories, deleting}
\entry {deleting a directory}{178}{deleting a directory}
\entry {renaming a file}{179}{renaming a file}
\entry {creating a directory}{180}{creating a directory}
\entry {directories, creating}{180}{directories, creating}
\entry {status of a file}{181}{status of a file}
\entry {attributes of a file}{181}{attributes of a file}
\entry {file attributes}{181}{file attributes}
\entry {inode number}{184}{inode number}
\entry {file owner}{186}{file owner}
\entry {owner of a file}{186}{owner of a file}
\entry {group owner of a file}{186}{group owner of a file}
\entry {file permission bits}{188}{file permission bits}
\entry {sticky bit}{189}{sticky bit}
\entry {permission to access a file}{190}{permission to access a file}
\entry {access permission for a file}{190}{access permission for a file}
\entry {file access permission}{190}{file access permission}
\entry {file creation mask}{190}{file creation mask}
\entry {umask}{190}{umask}
\entry {testing access permission}{192}{testing access permission}
\entry {access, testing for}{192}{access, testing for}
\entry {setuid programs and file access}{192}{setuid programs and file access}
\entry {file access time}{194}{file access time}
\entry {file modification time}{194}{file modification time}
\entry {file attribute modification time}{194}{file attribute modification time}
\entry {creating special files}{196}{creating special files}
\entry {special files}{196}{special files}
\entry {TMPDIR environment variable}{198}{TMPDIR environment variable}
\entry {pipe}{201}{pipe}
\entry {FIFO special file}{201}{FIFO special file}
\entry {creating a pipe}{201}{creating a pipe}
\entry {opening a pipe}{201}{opening a pipe}
\entry {interprocess communication, with pipes}{201}{interprocess communication, with pipes}
\entry {creating a pipe to a subprocess}{203}{creating a pipe to a subprocess}
\entry {pipe to a subprocess}{203}{pipe to a subprocess}
\entry {filtering i/o through subprocess}{203}{filtering i/o through subprocess}
\entry {creating a FIFO special file}{204}{creating a FIFO special file}
\entry {interprocess communication, with FIFO}{204}{interprocess communication, with FIFO}
\entry {socket}{207}{socket}
\entry {interprocess communication, with sockets}{207}{interprocess communication, with sockets}
\entry {communication style (of a socket)}{207}{communication style (of a socket)}
\entry {style of communication (of a socket)}{207}{style of communication (of a socket)}
\entry {packet}{207}{packet}
\entry {byte stream}{207}{byte stream}
\entry {stream (sockets)}{207}{stream (sockets)}
\entry {loss of data on sockets}{207}{loss of data on sockets}
\entry {data loss on sockets}{207}{data loss on sockets}
\entry {namespace (of socket)}{207}{namespace (of socket)}
\entry {domain (of socket)}{207}{domain (of socket)}
\entry {socket namespace}{207}{socket namespace}
\entry {socket domain}{207}{socket domain}
\entry {network protocol}{208}{network protocol}
\entry {protocol (of socket)}{208}{protocol (of socket)}
\entry {socket protocol}{208}{socket protocol}
\entry {protocol family}{208}{protocol family}
\entry {address of socket}{209}{address of socket}
\entry {name of socket}{209}{name of socket}
\entry {binding a socket address}{209}{binding a socket address}
\entry {socket address (name) binding}{209}{socket address (name) binding}
\entry {file namespace, for sockets}{212}{file namespace, for sockets}
\entry {Internet namespace, for sockets}{215}{Internet namespace, for sockets}
\entry {host address, Internet}{216}{host address, Internet}
\entry {Internet host address}{216}{Internet host address}
\entry {network number}{216}{network number}
\entry {local network address number}{216}{local network address number}
\entry {standard dot notation, for Internet addresses}{217}{standard dot notation, for Internet addresses}
\entry {dot notation, for Internet addresses}{217}{dot notation, for Internet addresses}
\entry {hosts database}{219}{hosts database}
\entry {converting host name to address}{219}{converting host name to address}
\entry {converting host address to name}{219}{converting host address to name}
\entry {port number}{221}{port number}
\entry {services database}{222}{services database}
\entry {converting service name to port number}{222}{converting service name to port number}
\entry {converting port number to service name}{222}{converting port number to service name}
\entry {byte order conversion, for socket}{224}{byte order conversion, for socket}
\entry {converting byte order}{224}{converting byte order}
\entry {big-endian}{224}{big-endian}
\entry {little-endian}{224}{little-endian}
\entry {network byte order}{224}{network byte order}
\entry {protocols database}{225}{protocols database}
\entry {TCP (Internet protocol)}{225}{TCP (Internet protocol)}
\entry {creating a socket}{228}{creating a socket}
\entry {socket, creating}{228}{socket, creating}
\entry {opening a socket}{228}{opening a socket}
\entry {socket, closing}{229}{socket, closing}
\entry {closing a socket}{229}{closing a socket}
\entry {shutting down a socket}{229}{shutting down a socket}
\entry {socket shutdown}{229}{socket shutdown}
\entry {creating a socket pair}{229}{creating a socket pair}
\entry {socket pair}{229}{socket pair}
\entry {opening a socket pair}{229}{opening a socket pair}
\entry {connection}{230}{connection}
\entry {client}{230}{client}
\entry {server}{230}{server}
\entry {connecting a socket}{231}{connecting a socket}
\entry {socket, connecting}{231}{socket, connecting}
\entry {socket, initiating a connection}{231}{socket, initiating a connection}
\entry {socket, client actions}{231}{socket, client actions}
\entry {listening (sockets)}{232}{listening (sockets)}
\entry {sockets, server actions}{232}{sockets, server actions}
\entry {sockets, listening}{232}{sockets, listening}
\entry {sockets, accepting connections}{233}{sockets, accepting connections}
\entry {accepting connections}{233}{accepting connections}
\entry {reading from a socket}{234}{reading from a socket}
\entry {writing to a socket}{234}{writing to a socket}
\entry {out-of-band data}{240}{out-of-band data}
\entry {high-priority data}{240}{high-priority data}
\entry {urgent socket condition}{240}{urgent socket condition}
\entry {datagram socket}{243}{datagram socket}
\entry {sending a datagram}{243}{sending a datagram}
\entry {transmitting datagrams}{243}{transmitting datagrams}
\entry {datagrams, transmitting}{243}{datagrams, transmitting}
\entry {receiving datagrams}{244}{receiving datagrams}
\entry {socket options}{249}{socket options}
\entry {level, for socket options}{249}{level, for socket options}
\entry {socket option level}{249}{socket option level}
\entry {networks database}{252}{networks database}
\entry {converting network number to network name}{252}{converting network number to network name}
\entry {converting network name to network number}{252}{converting network name to network number}
\entry {terminal identification}{255}{terminal identification}
\entry {identifying terminals}{255}{identifying terminals}
\entry {terminal input queue}{255}{terminal input queue}
\entry {typeahead buffer}{255}{typeahead buffer}
\entry {terminal output queue}{256}{terminal output queue}
\entry {canonical input processing}{256}{canonical input processing}
\entry {noncanonical input processing}{256}{noncanonical input processing}
\entry {terminal mode data types}{257}{terminal mode data types}
\entry {terminal mode functions}{258}{terminal mode functions}
\entry {parity checking}{261}{parity checking}
\entry {break condition, detecting}{262}{break condition, detecting}
\entry {modem status lines}{264}{modem status lines}
\entry {carrier detect}{264}{carrier detect}
\entry {modem disconnect}{264}{modem disconnect}
\entry {echo of terminal input}{266}{echo of terminal input}
\entry {interactive signals, from terminal}{267}{interactive signals, from terminal}
\entry {line speed}{268}{line speed}
\entry {baud rate}{268}{baud rate}
\entry {terminal line speed}{268}{terminal line speed}
\entry {terminal line speed}{268}{terminal line speed}
\entry {EOF character}{271}{EOF character}
\entry {EOL character}{271}{EOL character}
\entry {EOL2 character}{271}{EOL2 character}
\entry {ERASE character}{271}{ERASE character}
\entry {WERASE character}{272}{WERASE character}
\entry {KILL character}{272}{KILL character}
\entry {REPRINT character}{272}{REPRINT character}
\entry {INTR character}{272}{INTR character}
\entry {interrupt character}{272}{interrupt character}
\entry {QUIT character}{273}{QUIT character}
\entry {SUSP character}{273}{SUSP character}
\entry {suspend character}{273}{suspend character}
\entry {DSUSP character}{273}{DSUSP character}
\entry {delayed suspend character}{273}{delayed suspend character}
\entry {START character}{274}{START character}
\entry {STOP character}{274}{STOP character}
\entry {LNEXT character}{274}{LNEXT character}
\entry {DISCARD character}{275}{DISCARD character}
\entry {STATUS character}{275}{STATUS character}
\entry {MIN termios slot}{275}{MIN termios slot}
\entry {TIME termios slot}{276}{TIME termios slot}
\entry {terminal line control functions}{277}{terminal line control functions}
\entry {break condition, generating}{277}{break condition, generating}
\entry {flushing terminal output queue}{277}{flushing terminal output queue}
\entry {terminal output queue, flushing}{277}{terminal output queue, flushing}
\entry {clearing terminal input queue}{278}{clearing terminal input queue}
\entry {terminal input queue, clearing}{278}{terminal input queue, clearing}
\entry {flow control, terminal}{278}{flow control, terminal}
\entry {terminal flow control}{278}{terminal flow control}
\entry {domain error}{281}{domain error}
\entry {range error}{281}{range error}
\entry {trigonometric functions}{282}{trigonometric functions}
\entry {pi (trigonometric constant)}{282}{pi (trigonometric constant)}
\entry {inverse trigonmetric functions}{282}{inverse trigonmetric functions}
\entry {exponentiation functions}{283}{exponentiation functions}
\entry {power functions}{283}{power functions}
\entry {logarithm functions}{283}{logarithm functions}
\entry {square root function}{284}{square root function}
\entry {cube root function}{284}{cube root function}
\entry {hyperbolic functions}{285}{hyperbolic functions}
\entry {inverse hyperbolic functions}{285}{inverse hyperbolic functions}
\entry {random numbers}{285}{random numbers}
\entry {pseudo-random numbers}{285}{pseudo-random numbers}
\entry {seed (for random numbers)}{285}{seed (for random numbers)}
\entry {NaN}{289}{NaN}
\entry {not a number}{289}{not a number}
\entry {IEEE floating point}{289}{IEEE floating point}
\entry {absolute value functions}{290}{absolute value functions}
\entry {normalization functions (floating-point)}{291}{normalization functions (floating-point)}
\entry {rounding functions}{292}{rounding functions}
\entry {remainder functions}{292}{remainder functions}
\entry {converting floats to integers}{292}{converting floats to integers}
\entry {integer division functions}{293}{integer division functions}
\entry {parsing numbers (in formatted input)}{294}{parsing numbers (in formatted input)}
\entry {converting strings to numbers}{294}{converting strings to numbers}
\entry {number syntax, parsing}{294}{number syntax, parsing}
\entry {syntax, for reading numbers}{294}{syntax, for reading numbers}
\entry {Comparison Function}{299}{Comparison Function}
\entry {search function (for arrays)}{299}{search function (for arrays)}
\entry {binary search function (for arrays)}{299}{binary search function (for arrays)}
\entry {array search function}{299}{array search function}
\entry {sort function (for arrays)}{300}{sort function (for arrays)}
\entry {quick sort function (for arrays)}{300}{quick sort function (for arrays)}
\entry {array sort function}{300}{array sort function}
\entry {stable sorting}{300}{stable sorting}
\entry {Kermit the frog}{302}{Kermit the frog}
\entry {globbing}{306}{globbing}
\entry {word expansion}{315}{word expansion}
\entry {expansion of shell words}{315}{expansion of shell words}
\entry {tilde expansion}{316}{tilde expansion}
\entry {variable substitution}{316}{variable substitution}
\entry {substitution of variables and commands}{316}{substitution of variables and commands}
\entry {command substitution}{316}{command substitution}
\entry {arithmetic expansion}{316}{arithmetic expansion}
\entry {field splitting}{316}{field splitting}
\entry {wildcard expansion}{316}{wildcard expansion}
\entry {quote removal}{316}{quote removal}
\entry {removal of quotes}{316}{removal of quotes}
\entry {CPU time}{321}{CPU time}
\entry {processor time}{321}{processor time}
\entry {clock ticks}{321}{clock ticks}
\entry {ticks, clock}{321}{ticks, clock}
\entry {time, elapsed CPU}{321}{time, elapsed CPU}
\entry {Gregorian calendar}{323}{Gregorian calendar}
\entry {time, calendar}{323}{time, calendar}
\entry {date and time}{323}{date and time}
\entry {calendar time}{323}{calendar time}
\entry {high-resolution time}{323}{high-resolution time}
\entry {local time}{323}{local time}
\entry {broken-down time}{323}{broken-down time}
\entry {epoch}{324}{epoch}
\entry {broken-down time}{327}{broken-down time}
\entry {calendar time and broken-down time}{327}{calendar time and broken-down time}
\entry {leap second}{327}{leap second}
\entry {Daylight Saving Time}{328}{Daylight Saving Time}
\entry {summer time}{328}{summer time}
\entry {time zone}{332}{time zone}
\entry {time zone database}{333}{time zone database}
\entry {setting an alarm}{335}{setting an alarm}
\entry {interval timer, setting}{335}{interval timer, setting}
\entry {alarms, setting}{335}{alarms, setting}
\entry {timers, setting}{335}{timers, setting}
\entry {real-time timer}{335}{real-time timer}
\entry {timer, real-time}{335}{timer, real-time}
\entry {virtual timer}{335}{virtual timer}
\entry {timer, virtual}{335}{timer, virtual}
\entry {profiling timer}{335}{profiling timer}
\entry {timer, profiling}{335}{timer, profiling}
\entry {resource limits}{341}{resource limits}
\entry {limits on resource usage}{341}{limits on resource usage}
\entry {usage limits}{341}{usage limits}
\entry {soft limit}{341}{soft limit}
\entry {hard limit}{341}{hard limit}
\entry {process priority}{343}{process priority}
\entry {priority of a process}{343}{priority of a process}
\entry {extended character sets}{345}{extended character sets}
\entry {wide characters}{345}{wide characters}
\entry {multibyte characters}{346}{multibyte characters}
\entry {basic byte sequence}{346}{basic byte sequence}
\entry {code, character}{349}{code, character}
\entry {character code}{349}{character code}
\entry {extended strings, converting representations}{350}{extended strings, converting representations}
\entry {converting extended strings}{350}{converting extended strings}
\entry {multibyte character, length of}{351}{multibyte character, length of}
\entry {length of multibyte character}{351}{length of multibyte character}
\entry {extended characters, converting}{352}{extended characters, converting}
\entry {converting extended characters}{352}{converting extended characters}
\entry {internationalization}{357}{internationalization}
\entry {locales}{357}{locales}
\entry {combining locales}{358}{combining locales}
\entry {categories for locales}{358}{categories for locales}
\entry {locale categories}{358}{locale categories}
\entry {changing the locale}{359}{changing the locale}
\entry {locale, changing}{359}{locale, changing}
\entry {monetary value formatting}{361}{monetary value formatting}
\entry {numeric value formatting}{361}{numeric value formatting}
\entry {decimal-point separator}{362}{decimal-point separator}
\entry {grouping of digits}{362}{grouping of digits}
\entry {currency symbols}{363}{currency symbols}
\entry {non-local exits}{367}{non-local exits}
\entry {long jumps}{367}{long jumps}
\entry {signal}{371}{signal}
\entry {generation of signals}{372}{generation of signals}
\entry {delivery of signals}{372}{delivery of signals}
\entry {pending signals}{372}{pending signals}
\entry {blocked signals}{372}{blocked signals}
\entry {specified action (for a signal)}{373}{specified action (for a signal)}
\entry {default action (for a signal)}{373}{default action (for a signal)}
\entry {signal action}{373}{signal action}
\entry {catching signals}{373}{catching signals}
\entry {signal names}{373}{signal names}
\entry {names of signals}{373}{names of signals}
\entry {signal number}{373}{signal number}
\entry {program error signals}{374}{program error signals}
\entry {exception}{375}{exception}
\entry {floating-point exception}{375}{floating-point exception}
\entry {illegal instruction}{376}{illegal instruction}
\entry {segmentation violation}{376}{segmentation violation}
\entry {bus error}{376}{bus error}
\entry {abort signal}{376}{abort signal}
\entry {program termination signals}{377}{program termination signals}
\entry {termination signal}{377}{termination signal}
\entry {interrupt signal}{377}{interrupt signal}
\entry {quit signal}{378}{quit signal}
\entry {quit signal}{378}{quit signal}
\entry {kill signal}{378}{kill signal}
\entry {hangup signal}{378}{hangup signal}
\entry {alarm signal}{379}{alarm signal}
\entry {virtual time alarm signal}{379}{virtual time alarm signal}
\entry {profiling alarm signal}{379}{profiling alarm signal}
\entry {input available signal}{379}{input available signal}
\entry {output possible signal}{379}{output possible signal}
\entry {urgent data signal}{379}{urgent data signal}
\entry {job control signals}{380}{job control signals}
\entry {child process signal}{380}{child process signal}
\entry {continue signal}{380}{continue signal}
\entry {stop signal}{380}{stop signal}
\entry {interactive stop signal}{381}{interactive stop signal}
\entry {terminal input signal}{381}{terminal input signal}
\entry {terminal output signal}{381}{terminal output signal}
\entry {pipe signal}{382}{pipe signal}
\entry {broken pipe signal}{382}{broken pipe signal}
\entry {lost resource signal}{382}{lost resource signal}
\entry {user signals}{382}{user signals}
\entry {signal messages}{383}{signal messages}
\entry {signal actions}{384}{signal actions}
\entry {establishing a handler}{384}{establishing a handler}
\entry {signal function}{384}{\code {signal} function}
\entry {default action for a signal}{385}{default action for a signal}
\entry {ignore action for a signal}{385}{ignore action for a signal}
\entry {sigaction function}{386}{\code {sigaction} function}
\entry {signal flags}{389}{signal flags}
\entry {flags for sigaction}{389}{flags for \code {sigaction}}
\entry {sigaction flags}{389}{\code {sigaction} flags}
\entry {initial signal actions}{390}{initial signal actions}
\entry {signal handler function}{391}{signal handler function}
\entry {non-local exit, from signal handler}{393}{non-local exit, from signal handler}
\entry {race conditions, relating to signals}{394}{race conditions, relating to signals}
\entry {handling multiple signals}{395}{handling multiple signals}
\entry {successive signals}{395}{successive signals}
\entry {merging of signals}{395}{merging of signals}
\entry {restrictions on signal handler functions}{398}{restrictions on signal handler functions}
\entry {volatile declarations}{398}{\code {volatile} declarations}
\entry {reentrant functions}{398}{reentrant functions}
\entry {EINTR, and restarting interrupted primitives}{403}{EINTR, and restarting interrupted primitives}
\entry {restarting interrupted primitives}{403}{restarting interrupted primitives}
\entry {interrupting primitives}{403}{interrupting primitives}
\entry {primitives, interrupting}{403}{primitives, interrupting}
\entry {sending signals}{403}{sending signals}
\entry {raising signals}{403}{raising signals}
\entry {signals, generating}{403}{signals, generating}
\entry {killing a process}{405}{killing a process}
\entry {interprocess communication, with signals}{407}{interprocess communication, with signals}
\entry {blocking signals}{408}{blocking signals}
\entry {signal set}{409}{signal set}
\entry {signal mask}{410}{signal mask}
\entry {process signal mask}{410}{process signal mask}
\entry {blocking signals, in a handler}{412}{blocking signals, in a handler}
\entry {pending signals, checking for}{413}{pending signals, checking for}
\entry {blocked signals, checking for}{413}{blocked signals, checking for}
\entry {checking for pending signals}{413}{checking for pending signals}
\entry {timing error in signal handling}{415}{timing error in signal handling}
\entry {waiting for a signal}{416}{waiting for a signal}
\entry {pause function}{416}{\code {pause} function}
\entry {process}{425}{process}
\entry {program arguments}{425}{program arguments}
\entry {command line arguments}{425}{command line arguments}
\entry {arguments, to program}{425}{arguments, to program}
\entry {program startup}{425}{program startup}
\entry {startup of program}{425}{startup of program}
\entry {invocation of program}{425}{invocation of program}
\entry {main function}{425}{\code {main} function}
\entry {argc (program argument count)}{425}{argc (program argument count)}
\entry {argv (program argument vector)}{425}{argv (program argument vector)}
\entry {program argument syntax}{426}{program argument syntax}
\entry {syntax, for program arguments}{426}{syntax, for program arguments}
\entry {command argument syntax}{426}{command argument syntax}
\entry {long-named options}{426}{long-named options}
\entry {program arguments, parsing}{427}{program arguments, parsing}
\entry {command arguments, parsing}{427}{command arguments, parsing}
\entry {parsing program arguments}{427}{parsing program arguments}
\entry {environment variable}{433}{environment variable}
\entry {environment}{433}{environment}
\entry {environment access}{434}{environment access}
\entry {environment representation}{434}{environment representation}
\entry {standard environment variables}{435}{standard environment variables}
\entry {HOME environment variable}{435}{HOME environment variable}
\entry {home directory}{435}{home directory}
\entry {LOGNAME environment variable}{435}{LOGNAME environment variable}
\entry {PATH environment variable}{435}{PATH environment variable}
\entry {TERM environment variable}{436}{TERM environment variable}
\entry {TZ environment variable}{436}{TZ environment variable}
\entry {LANG environment variable}{436}{LANG environment variable}
\entry {LC{\_}COLLATE environment variable}{436}{LC{\_}COLLATE environment variable}
\entry {LC{\_}CTYPE environment variable}{436}{LC{\_}CTYPE environment variable}
\entry {LC{\_}MONETARY environment variable}{436}{LC{\_}MONETARY environment variable}
\entry {LC{\_}NUMERIC environment variable}{436}{LC{\_}NUMERIC environment variable}
\entry {LC{\_}TIME environment variable}{436}{LC{\_}TIME environment variable}
\entry {{\_}POSIX{\_}OPTION{\_}ORDER environment variable.}{436}{{\_}POSIX{\_}OPTION{\_}ORDER environment variable.}
\entry {program termination}{437}{program termination}
\entry {process termination}{437}{process termination}
\entry {exit status value}{437}{exit status value}
\entry {exit status}{437}{exit status}
\entry {aborting a program}{439}{aborting a program}
\entry {process}{441}{process}
\entry {child process}{441}{child process}
\entry {parent process}{441}{parent process}
\entry {running a command}{441}{running a command}
\entry {process ID}{442}{process ID}
\entry {process lifetime}{442}{process lifetime}
\entry {creating a process}{442}{creating a process}
\entry {forking a process}{442}{forking a process}
\entry {child process}{442}{child process}
\entry {parent process}{442}{parent process}
\entry {process image}{442}{process image}
\entry {executing a file}{444}{executing a file}
\entry {exec functions}{444}{\code {exec} functions}
\entry {process completion}{447}{process completion}
\entry {waiting for completion of child process}{447}{waiting for completion of child process}
\entry {testing exit status of child process}{447}{testing exit status of child process}
\entry {process groups}{453}{process groups}
\entry {job control}{453}{job control}
\entry {job}{453}{job}
\entry {session}{453}{session}
\entry {shell}{453}{shell}
\entry {session}{453}{session}
\entry {session leader}{453}{session leader}
\entry {controlling terminal}{454}{controlling terminal}
\entry {foreground job}{454}{foreground job}
\entry {background job}{454}{background job}
\entry {stopped job}{454}{stopped job}
\entry {job control is optional}{454}{job control is optional}
\entry {controlling process}{455}{controlling process}
\entry {controlling terminal, access to}{455}{controlling terminal, access to}
\entry {SIGTTIN, from background job}{455}{\code {SIGTTIN}, from background job}
\entry {SIGTTOU, from background job}{455}{\code {SIGTTOU}, from background job}
\entry {orphaned process group}{455}{orphaned process group}
\entry {job control, enabling}{458}{job control, enabling}
\entry {subshell}{458}{subshell}
\entry {job control, enabling}{458}{job control, enabling}
\entry {launching jobs}{460}{launching jobs}
\entry {process group leader}{460}{process group leader}
\entry {process group ID}{460}{process group ID}
\entry {race conditions, relating to job control}{460}{race conditions, relating to job control}
\entry {foreground job, launching}{463}{foreground job, launching}
\entry {background job, launching}{464}{background job, launching}
\entry {stopped jobs, detecting}{465}{stopped jobs, detecting}
\entry {terminated jobs, detecting}{465}{terminated jobs, detecting}
\entry {SIGCHLD, handling of}{465}{\code {SIGCHLD}, handling of}
\entry {stopped jobs, continuing}{468}{stopped jobs, continuing}
\entry {process group functions}{470}{process group functions}
\entry {job control functions}{470}{job control functions}
\entry {controlling terminal, determining}{470}{controlling terminal, determining}
\entry {BSD compatibility library}{471}{BSD compatibility library}
\entry {login name}{475}{login name}
\entry {user name}{475}{user name}
\entry {user ID}{475}{user ID}
\entry {group name}{475}{group name}
\entry {group ID}{475}{group ID}
\entry {persona}{475}{persona}
\entry {effective user ID}{475}{effective user ID}
\entry {effective group ID}{475}{effective group ID}
\entry {real user ID}{476}{real user ID}
\entry {real group ID}{476}{real group ID}
\entry {supplementary group IDs}{476}{supplementary group IDs}
\entry {setuid programs}{477}{\code {setuid} programs}
\entry {login name, determining}{484}{login name, determining}
\entry {user ID, determining}{484}{user ID, determining}
\entry {user database}{485}{user database}
\entry {password database}{485}{password database}
\entry {converting user ID to user name}{486}{converting user ID to user name}
\entry {converting user name to user ID}{486}{converting user name to user ID}
\entry {scanning the user list}{486}{scanning the user list}
\entry {group database}{487}{group database}
\entry {converting group name to group ID}{488}{converting group name to group ID}
\entry {converting group ID to group name}{488}{converting group ID to group name}
\entry {scanning the group list}{488}{scanning the group list}
\entry {POSIX capacity limits}{495}{POSIX capacity limits}
\entry {limits, POSIX}{495}{limits, POSIX}
\entry {capacity limits, POSIX}{495}{capacity limits, POSIX}
\entry {limits, program argument size}{495}{limits, program argument size}
\entry {limits, number of processes}{495}{limits, number of processes}
\entry {limits, number of open files}{495}{limits, number of open files}
\entry {limits, time zone name length}{496}{limits, time zone name length}
\entry {limits, number of supplementary group IDs}{496}{limits, number of supplementary group IDs}
\entry {POSIX optional features}{496}{POSIX optional features}
\entry {optional POSIX features}{496}{optional POSIX features}
\entry {limits, link count of files}{503}{limits, link count of files}
\entry {limits, terminal input queue}{503}{limits, terminal input queue}
\entry {limits, file name length}{503}{limits, file name length}
\entry {limits, pipe buffer size}{503}{limits, pipe buffer size}
\entry {consistency checking}{511}{consistency checking}
\entry {impossible events}{511}{impossible events}
\entry {assertions}{511}{assertions}
\entry {variable number of arguments}{512}{variable number of arguments}
\entry {variadic functions}{512}{variadic functions}
\entry {optional arguments}{512}{optional arguments}
\entry {function prototypes (variadic)}{513}{function prototypes (variadic)}
\entry {prototypes for variadic functions}{513}{prototypes for variadic functions}
\entry {variadic function prototypes}{513}{variadic function prototypes}
\entry {variadic function argument access}{514}{variadic function argument access}
\entry {arguments (variadic functions)}{514}{arguments (variadic functions)}
\entry {number of arguments passed}{515}{number of arguments passed}
\entry {how many arguments}{515}{how many arguments}
\entry {arguments, how many}{515}{arguments, how many}
\entry {variadic functions, calling}{515}{variadic functions, calling}
\entry {calling variadic functions}{515}{calling variadic functions}
\entry {declaring variadic functions}{515}{declaring variadic functions}
\entry {default argument promotions}{516}{default argument promotions}
\entry {argument promotion}{516}{argument promotion}
\entry {null pointer constant}{519}{null pointer constant}
\entry {integer type width}{520}{integer type width}
\entry {width of integer type}{520}{width of integer type}
\entry {type measurements, integer}{520}{type measurements, integer}
\entry {integer type range}{521}{integer type range}
\entry {range of integer type}{521}{range of integer type}
\entry {limits, integer types}{521}{limits, integer types}
\entry {floating type measurements}{522}{floating type measurements}
\entry {measurements of floating types}{522}{measurements of floating types}
\entry {type measurements, floating}{522}{type measurements, floating}
\entry {limits, floating types}{522}{limits, floating types}
\entry {sign (of floating point number)}{523}{sign (of floating point number)}
\entry {base (of floating point number)}{523}{base (of floating point number)}
\entry {radix (of floating point number)}{523}{radix (of floating point number)}
\entry {exponent (of floating point number)}{523}{exponent (of floating point number)}
\entry {bias (of floating point number exponent)}{523}{bias (of floating point number exponent)}
\entry {mantissa (of floating point number)}{523}{mantissa (of floating point number)}
\entry {significand (of floating point number)}{523}{significand (of floating point number)}
\entry {precision (of floating point number)}{523}{precision (of floating point number)}
\entry {hidden bit (of floating point number mantissa)}{523}{hidden bit (of floating point number mantissa)}
\entry {normalized floating point number}{524}{normalized floating point number}
\entry {IEEE floating point representation}{527}{IEEE floating point representation}
\entry {floating point, IEEE}{527}{floating point, IEEE}
\entry {installing the library}{611}{installing the library}
\entry {reporting bugs}{614}{reporting bugs}
\entry {bugs, reporting}{614}{bugs, reporting}